home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / cmln0986.arc / EXPON1.LTG < prev    next >
Text File  |  1980-02-17  |  3KB  |  65 lines
  1.     1: {======================================================================
  2.     2: 
  3.     3:                           POWER.PAS
  4.     4: 
  5.     5:                   Routine to calulate x^n
  6.     6: 
  7.     7:         Usage:  Result : real;      (*x^n*)
  8.     8:                 x      : real;      (*base*)
  9.     9:                 n      : real;      (*exponent*)
  10.    10: 
  11.    11:                 Result := Power( x, n );
  12.    12: 
  13.    13:         Method: If the exponent is not integral, the result is
  14.    14:                 calculated using the log-exponential method.  If
  15.    15:                 n has no fractional part, the result is calculated
  16.    16:                 by the recursion method.  A call with base = 0 will
  17.    17:                 always return 0.
  18.    18: 
  19.    19:         Errors: The only error condition is a negative base with a
  20.    20:                 non-integral exponent, which causes an error in the
  21.    21:                 log routine.  POWER.PAS assumes that the log routine
  22.    22:                 will handle the error.  If the commented-out code on
  23.    23:                 lines 55 and 56 are uncommented, Power will call a
  24.    24:                 user-supplied routine, Error, with the single argument
  25.    25:                 LOG_ARG.
  26.    26: 
  27.    27: ======================================================================}
  28.    28: 
  29.    29: function Power( x : real; n : real ) : real;
  30.    30: 
  31.    31:   Const
  32.    32:       LOG_ARG = 1;                          {for error trapping}
  33.    33: 
  34.    34:   {local function to do recursion}
  35.    35: 
  36.    36:   function pwr( n : integer ) : real;
  37.    37: 
  38.    38:   begin {pwr}
  39.    39:       if n = 1 then                         {case 1 of rule}
  40.    40:           pwr := x                          {--end recursion}
  41.    41:       else if odd( n ) then                 {case 2 of rule}
  42.    42:           pwr := sqr( pwr( n div 2 ) ) * x  {--do recursion}
  43.    43:       else                                  {case 3 of rule}
  44.    44:           pwr := sqr( pwr( n div 2 ) );     {--do recursion}
  45.    45:   end; {pwr}
  46.    46: 
  47.    47: begin {Power}
  48.    48: 
  49.    49:     if x = 0 then                           {pick off the easy}
  50.    50:         Power := 0                          {--cases of x = 0}
  51.    51:     else if n = 0 then                      {--and n = 0 first}
  52.    52:         Power := 1
  53.    53:     else if frac( n ) <> 0 then             {non-integral exponent}
  54.    54:         begin
  55.    55:        (*   if x < 0 then                   {illegal log argument?}è   56:                 Error(LOG_ARG);   *)        {yes - trap it}
  56.    57:             Power := exp( n * ln ( x ) )
  57.    58:         end
  58.    59:     else if n < 0 then                      {negative integral exponent}
  59.    60:         Power := 1/pwr( -trunc( n ) )       {--x^(-n) becomes 1/x^n}
  60.    61:     else                                    {positive integral exponent}
  61.    62:         Power := pwr( trunc( n ) );         {--calculate it recursively}
  62.    63: 
  63.    64: end; {Power}
  64.  
  65.